import { thin } from "../thin3.mjs";
import { clearafterqueue } from "./delay_render.mjs";
import { alert } from "./dialog.mjs";
import thin_pop from "./thin_pop.mjs";

/**
 * AJAX请求处理函数
 * @param {Object} options - AJAX请求配置选项
 * @param {string} options.url - 请求URL
 * @param {Object} options.data - 请求数据
 * @param {Object} options.files - 文件数据（如果有）
 * @param {string} options.dataType - 响应数据类型，默认为'json'
 * @param {string} options.type - 请求方法，默认为'POST'
 * @param {boolean} options.withCredentials - 是否携带凭证，默认为true
 * @param {string} options.contentType - 请求内容类型，默认为'application/JSON'
 * @param {Function} options.success - 成功回调函数
 * @param {Function} options.error - 错误回调函数
 */
export default function ({
  url,
  data,
  files,
  dataType = "json",
  type = "POST",
  withCredentials,
  contentType = "application/JSON",
  success,
  error,
}) {
  // 创建XMLHttpRequest实例
  let xhr = new XMLHttpRequest();
  xhr.withCredentials = withCredentials || true;

  // 定义回调函数变量
  let done, fail, always, pop;

  /**
   * 执行AJAX请求的核心函数
   */
  function ajax() {
    // 设置请求状态变化的处理函数
    xhr.onreadystatechange = function () {
      if (xhr.readyState !== 4) {
        // 请求未完成，继续等待
      } else if (xhr.status === 200) {
        // 请求成功
        let d = xhr.responseText;

        // 根据数据类型处理响应
        switch (dataType) {
          case "json":
            if (success) success(JSON.parse(d), xhr.statusText, xhr);
            if (done) done(JSON.parse(d), xhr.statusText, xhr);
            if (pop) pop(JSON.parse(d));
            break;
          default:
            if (success) success(d, xhr.statusText, xhr);
            if (done) done(d, xhr.statusText, xhr);
            break;
        }
      } else {
        // 请求失败处理
        try {
          xhr.responseJSON = JSON.parse(xhr.responseText);
        } catch {}

        if (xhr.status === 0) {
          console.log({ readyState: xhr.readyState, status: xhr.status });
        } else if (error) {
          error(xhr, xhr.statusText);
        } else {
          // 默认错误处理：显示警告对话框
          console.log({ error: xhr });
          alert(
            [
              { warning: "[[status]]([[statusText]])" },
              {
                if: "responseJSON",
                then: {
                  div: [
                    { div: "[[code]]", when: "code" },
                    { div: "[[sqlMessage]]", when: "sqlMessage" },
                  ],
                  datapath: "responseJSON",
                },
              },
            ],
            xhr
          );
        }
      }
      // 清理延迟渲染队列
      clearafterqueue();
    };

    if (files) {
      // data.files = files;
      let formdata = new FormData();
      formdata.append("jdata", JSON.stringify(data));
      console.log({ files });
      Object.keys(files).forEach((key) => {
        console.log({ key });
        for (let file of files[key].files) {
          console.log({ file: file });
          formdata.append(
            files[key].path ? files[key].path + "/" + key : key,
            file
          );
        }
      });

      xhr.open("POST", url, true);
      // xhr.setRequestHeader("Content-Type", "multipart/form-data");
      xhr.send(formdata);
      // fetch(url, {
      //   method: "POST",
      //   body: formdata,
      // });
    }
    // 根据请求类型发送请求
    else
      switch (type.toUpperCase()) {
        case "POST":
          xhr.open(type, url, true);
          xhr.setRequestHeader("Content-Type", contentType);
          switch (contentType) {
            case "application/x-www-form-urlencoded":
              xhr.send(thin.serialize(data));
              break;
            default:
              xhr.send(JSON.stringify(data));
              break;
          }
          break;
        case "GET":
          xhr.open(type, `${url}?${thin.serialize(data)}`);
          xhr.send();
          break;
        default:
          xhr.open(type, url, true);
          xhr.send();
          break;
      }
    return this;
  }

  // 返回链式调用接口
  return ajax.call({
    // 设置成功回调
    done: function (fn) {
      done = fn;
      return this;
    },
    // 设置失败回调
    fail: function (fn) {
      error = fn;
      return this;
    },
    // 设置弹出层处理
    pop: function (template) {
      let render_template;
      pop = function (data) {
        let p = thin_pop({ ...template, data });
        if (render_template) p.render(render_template);
      };

      return {
        ...this,
        render: function (template) {
          render_template = template;
          return this;
        },
      };
    },
    // 中止请求
    abort: function () {
      xhr.abort();
      return this;
    },
  });
}
